//////////////////////////////////////////////////////////////

//SOURCE FILE: config_disco.c

//PROCESO PLANIFICADOR DE DISCO

//Autor: Pablo Bergna

//////////////////////////////////////////////////////////////
//locales
#include "../includes/config_disco.h"

/***********************************************************************
FUNCION: LEER_CONFIG

PROCESO: PPD

Autor: Pablo Bergna

PRE: mi_disco ya creado y alocado en memoria

POST: mi_disco queda seteado
con las configuraciones del archivo de conf.
Por ahora la ruta del archivo conf esta en la constante PPD_PATH_CONF

DEVUELVE: 	0 si sale bien
			-1 si el archivo de conf no existe
			-2 un parametro no fue encontrado

FUNCION PPAL: Abre el archivo de configuracion, lee sus valores
y los va descargando en donde corresponde dentro de mi_disco
para dejarlo seteado.

**********************************************************************/
uint8_t leer_config(td_disco* mi_disco){

	FILE* config;
	uint8_t err = 0;
	config = fopen(PPD_PATH_CONF,"r");
	if (config == NULL){
		printf("NO SE PUEDE ABRIR EL ARCHIVO DE CONFIGURACION LOCALIZADO EN %s",PPD_PATH_CONF);
		return -1;
	}
	//<HACER>

	//parámetro de cilindros
	mi_disco->chs_conf->cylinder = atoi(LeerParametroDeConfiguracion(DELIMITADOR_CILINDROS, config, &err));
	//parámetro de sectores
	mi_disco->chs_conf->sector = atoi(LeerParametroDeConfiguracion(DELIMITADOR_SECTORES, config, &err));
	//parámetro de heads
	mi_disco->chs_conf->head = atoi(LeerParametroDeConfiguracion(DELIMITADOR_CABEZAS, config, &err));
	//parámetro de id
	mi_disco->id_disco = LeerParametroDeConfiguracion(DELIMITADOR_ID_DISCO, config, &err);
	//parámetro path de disco FAT
	mi_disco->path = LeerParametroDeConfiguracion(DELIMITADOR_PATH_DISCO, config, &err);
	//parámetro de estado
	mi_disco->estado = 0;
	//parámetro de cilindro actual
	mi_disco->current_chs->cylinder = 1;
	//parámetro de cilindro actual
	mi_disco->current_chs->head = 1;
	//parámetro de sector actual
	mi_disco->current_chs->sector = 1;
	//parámetro de rpm
	mi_disco->rpm = atoi(LeerParametroDeConfiguracion(DELIMITADOR_RPM, config, &err));
	//parámetro de velocidad de lectura
	mi_disco->sector_read_speed = atoi(LeerParametroDeConfiguracion(DELIMITADOR_VELOCIDAD_LECTURA_SECTOR, config, &err));
	//parámetro de velocidad de escritura
	mi_disco->sector_write_speed = atoi(LeerParametroDeConfiguracion(DELIMITADOR_VELOCIDAD_ESCRITURA_SECTOR, config, &err));
	//parámetro de giro por sector
	mi_disco->sector_spin = (uint8_t)(abs(60000/mi_disco->rpm));
	//parámetro de tiempo entre pistas
	mi_disco->time_btw_track = atoi(LeerParametroDeConfiguracion(DELIMITADOR_TIEMPO_ENTRE_PISTAS, config, &err));
	//algoritmo de planificacion a usar
	mi_disco->algoritmo_planificador = atoi(LeerParametroDeConfiguracion(DELIMITADOR_ALGORITMO_PLANIFICADOR, config, &err));
	//cola de pedidos entrantes
	mi_disco->cola_pedidos_entrantes = NULL;
	//cola de pedidos salientes
	mi_disco->cola_pedidos_salientes = NULL;
	//lista de pedidos planificados
	mi_disco->lista_planificacion = NULL;

	fclose (config);




	//EJEMPLO PARA TESTEO

	/*

	//parámetro de cilindros
	mi_disco->chs_conf->cylinder = 1024;
	//parámetro de sectores
	mi_disco->chs_conf->sector = (uint16_t)(1024);
	//parámetro de cabezas
	mi_disco->chs_conf->head = 1;
	//parámetro de id
	strcpy("Mi Disco\n",mi_disco->id_disco);
	//parámetro path de disco FAT
	strcpy("/home/utn_so/disco_fat",mi_disco->path);
	//parámetro de estado
	mi_disco->estado = 0;
	//parámetro de cilindro actual
	mi_disco->current_chs->cylinder = 1;
	//parámetro de sector actual
	mi_disco->current_chs->sector = 1;
	//parámetro de cabeza actual
	mi_disco->current_chs->head = 1;
	//parámetro de rpm
	mi_disco->rpm = 6000;
	//parámetro de velocidad de lectura
	mi_disco->sector_read_speed = 10;
	//parámetro de velocidad de escritura
	mi_disco->sector_write_speed = 20;
	//parámetro de giro por sector
	mi_disco->sector_spin = 10;
	//parámetro de tiempo entre pistas
	mi_disco->time_btw_track = 1;

	*/

	//FIN EJEMPLO PARA TESTEO

	if (err == 1) return -2;

	return 0;

}





// retorna la subcadena comprendida entre los
// caracteres desde y hasta (hasta inclusive)
char* substring(char s[], int desde, int hasta)
{
   int i,j;
   int len=hasta-desde+1;
   //<HACER>
   // alocamos dinamicamente un string (o un char[])
   // del tamanio que necesitamos
   char *ret=(char*) malloc(sizeof(char)*len);

   // el for puede controlar mas de una variable
   for( j=0,i=desde; i==hasta; i++,j++ )
   {
      ret[j]=s[i];
   }
   ret[j]='\0';

   return ret;
}



